WebGL ēnotāja resursu piesaiste: resursu pārvaldības optimizācija

WebGL, tīmekļa 3D grafikas stūrakmens, dod iespēju izstrādātājiem veidot vizuāli satriecošas un interaktīvas pieredzes tieši tīmekļa pārlūkprogrammās. Optimālas veiktspējas un efektivitātes sasniegšana WebGL lietojumprogrammās ir atkarīga no efektīvas resursu pārvaldības, un būtisks aspekts ir tas, kā ēnotāji mijiedarbojas ar pamatā esošo grafikas aparatūru. Šis emuāra ieraksts iedziļinās WebGL ēnotāja resursu piesaistes sarežģītībā, sniedzot visaptverošu ceļvedi resursu pārvaldības optimizēšanai un kopējās atveidošanas veiktspējas uzlabošanai.

Ēnotāja resursu piesaistes izpratne

Ēnotāja resursu piesaiste ir process, kurā ēnotāja programmas piekļūst ārējiem resursiem, piemēram, tekstūrām, buferiem un viendabīgiem blokiem (uniform blocks). Efektīva piesaiste samazina virsnormas izmaksas un ļauj GPU ātri piekļūt datiem, kas nepieciešami atveidošanai. Nepareiza piesaiste var izraisīt veiktspējas vājos punktus, aizķeršanos un kopumā lēnu lietotāja pieredzi. Resursu piesaistes specifika atšķiras atkarībā no WebGL versijas un izmantotajiem resursiem.

WebGL 1 pret WebGL 2

WebGL ēnotāja resursu piesaistes ainava būtiski atšķiras starp WebGL 1 un WebGL 2. WebGL 2, kas veidots uz OpenGL ES 3.0 pamata, ievieš ievērojamus uzlabojumus resursu pārvaldībā un ēnotāja valodu iespējās. Šo atšķirību izpratne ir kritiska, lai rakstītu efektīvas un modernas WebGL lietojumprogrammas.

• WebGL 1: Balstās uz ierobežotāku piesaistes mehānismu kopumu. Galvenokārt resursiem piekļūst, izmantojot uniform mainīgos un atribūtus. Tekstūras vienības tiek piesaistītas tekstūrām, izmantojot izsaukumus, piemēram, gl.activeTexture() un gl.bindTexture(), kam seko uniform sampler mainīgā iestatīšana atbilstošajai tekstūras vienībai. Bufera objekti tiek piesaistīti mērķiem (piemēram, gl.ARRAY_BUFFER, gl.ELEMENT_ARRAY_BUFFER) un tiem piekļūst, izmantojot atribūtu mainīgos. WebGL 1 trūkst daudzu funkciju, kas vienkāršo un optimizē resursu pārvaldību WebGL 2.
• WebGL 2: Nodrošina sarežģītākus piesaistes mehānismus, tostarp uniform bufera objektus (UBO), ēnotāja glabāšanas bufera objektus (SSBO) un elastīgākas tekstūras piekļuves metodes. UBO un SSBO ļauj grupēt saistītus datus buferos, piedāvājot organizētāku un efektīvāku veidu, kā nodot datus ēnotājiem. Tekstūras piekļuve atbalsta vairākas tekstūras katram ēnotājam un nodrošina lielāku kontroli pār tekstūras filtrēšanu un paraugu ņemšanu. WebGL 2 funkcijas ievērojami uzlabo spēju optimizēt resursu pārvaldību.

Galvenie resursi un to piesaistes mehānismi

Vairāki galvenie resursi ir būtiski jebkurai WebGL atveidošanas cauruļvada shēmai. Izpratne par to, kā šie resursi tiek piesaistīti ēnotājiem, ir izšķiroša optimizācijai.

• Tekstūras: Tekstūras glabā attēlu datus un tiek plaši izmantotas materiālu uzklāšanai, reālistisku virsmas detaļu simulēšanai un vizuālo efektu radīšanai. Gan WebGL 1, gan WebGL 2 tekstūras tiek piesaistītas tekstūras vienībām. WebGL 1, funkcija gl.activeTexture() atlasa tekstūras vienību, un gl.bindTexture() piesaista tekstūras objektu šai vienībai. WebGL 2 var piesaistīt vairākas tekstūras vienlaicīgi un izmantot sarežģītākas paraugu ņemšanas metodes. The sampler2D un samplerCube uniform mainīgie jūsu ēnotājā tiek izmantoti, lai atsauktos uz tekstūrām. Piemēram, jūs varētu izmantot:

              uniform sampler2D u_texture;
  
              
  
                
                  Copy
                
              
            

• Buferi: Buferi glabā virsotnes datus, indeksu datus un citu skaitlisku informāciju, kas nepieciešama ēnotājiem. Gan WebGL 1, gan WebGL 2 bufera objekti tiek izveidoti, izmantojot gl.createBuffer(), piesaistīti mērķim (piemēram, gl.ARRAY_BUFFER virsotnes datiem, gl.ELEMENT_ARRAY_BUFFER indeksu datiem), izmantojot gl.bindBuffer(), un pēc tam aizpildīti ar datiem, izmantojot gl.bufferData(). WebGL 1, virsotnes atribūtu rādītāji (piemēram, gl.vertexAttribPointer()) tiek izmantoti, lai saistītu bufera datus ar atribūtu mainīgajiem ēnotājā. WebGL 2 ievieš tādas funkcijas kā transform feedback, kas ļauj tvert ēnotāja izvadi un saglabāt to atpakaļ buferī vēlākai lietošanai.

              attribute vec3 a_position;
  attribute vec2 a_texCoord;
  
  // ... other shader code
  
              
  
                
                  Copy
                
              
            

• Uniforms: Uniform mainīgie tiek izmantoti, lai nodotu nemainīgus vai objekta specifiskus datus ēnotājiem. Šie mainīgie paliek nemainīgi visā viena objekta vai visas ainas atveidošanas laikā. Gan WebGL 1, gan WebGL 2 uniform mainīgie tiek iestatīti, izmantojot tādas funkcijas kā gl.uniform1f(), gl.uniform2fv(), gl.uniformMatrix4fv() utt. Šīs funkcijas kā argumentus pieņem uniform atrašanās vietu (iegūtu no gl.getUniformLocation()) un iestatāmo vērtību.

              uniform mat4 u_modelViewMatrix;
  uniform mat4 u_projectionMatrix;
  
              
  
                
                  Copy
                
              
            

• Uniform Bufera Objekti (UBO - WebGL 2): UBO grupē saistītus uniformus vienā buferī, piedāvājot ievērojamas veiktspējas priekšrocības, īpaši lielākām uniformu datu kopām. UBO tiek piesaistīti piesaistes punktam un tiem piekļūst ēnotājā, izmantojot sintaksi `layout(binding = 0) uniform YourBlockName { ... }`. Tas ļauj vairākiem ēnotājiem dalīties ar vieniem un tiem pašiem uniforma datiem no viena bufera.

              layout(std140) uniform Matrices {
    mat4 u_modelViewMatrix;
    mat4 u_projectionMatrix;
  };
  
              
  
                
                  Copy
                
              
            

• Ēnotāja Glabāšanas Bufera Objekti (SSBO - WebGL 2): SSBO nodrošina veidu, kā ēnotāji var lasīt un rakstīt lielu daudzumu datu elastīgākā veidā salīdzinājumā ar UBO. Tie tiek deklarēti, izmantojot `buffer` kvalifikatoru, un var glabāt jebkura veida datus. SSBO ir īpaši noderīgi sarežģītu datu struktūru glabāšanai un sarežģītām aprēķināšanas darbībām, piemēram, daļiņu simulācijām vai fizikas aprēķiniem.

              layout(std430, binding = 1) buffer ParticleData {
    vec4 position;
    vec4 velocity;
    float lifetime;
  };
  
              
  
                
                  Copy
                
              
            

Labākā prakse resursu pārvaldības optimizēšanai

Efektīva resursu pārvaldība ir nepārtraukts process. Apsveriet šīs labākās prakses, lai optimizētu savu WebGL ēnotāja resursu piesaisti.

1. Minimālizējiet stāvokļa maiņas

WebGL stāvokļa maiņa (piemēram, tekstūru piesaistīšana, ēnotāja programmu maiņa, uniform mainīgo atjaunināšana) var būt salīdzinoši dārga. Maksimāli samaziniet stāvokļa maiņas. Organizējiet savu atveidošanas cauruļvadu, lai minimizētu piesaistes izsaukumu skaitu. Piemēram, sakārtojiet atveidošanas izsaukumus, pamatojoties uz ēnotāja programmu un izmantoto tekstūru. Tas grupēs atveidošanas izsaukumus ar vienādām piesaistes prasībām, samazinot dārgo stāvokļa maiņu skaitu.

2. Izmantojiet tekstūru atlāzus

Tekstūru atlāzi apvieno vairākas mazākas tekstūras vienā lielākā tekstūrā. Tas samazina renderēšanas laikā nepieciešamo tekstūru piesaistes skaitu. Atveidojot dažādas atlāza daļas, izmantojiet tekstūras koordinātes, lai ņemtu paraugus no pareizajiem reģioniem atlāza ietvaros. Šī tehnika ievērojami uzlabo veiktspēju, īpaši atveidojot daudzus objektus ar dažādām tekstūrām. Daudzi spēļu dzinēji plaši izmanto tekstūru atlāzus.

3. Izmantojiet instancēšanu

Instancēšana ļauj atveidot vairākus vienas ģeometrijas instanci ar potenciāli atšķirīgām transformācijām un materiāliem. Tā vietā, lai katrai instancei veiktu atsevišķu zīmēšanas izsaukumu, varat izmantot instancēšanu, lai uzzīmētu visus instanci vienā zīmēšanas izsaukumā. Nododiet instancei specifiskus datus, izmantojot virsotnes atribūtus, uniform bufera objektus (UBO) vai ēnotāja glabāšanas bufera objektus (SSBO). Tas samazina zīmēšanas izsaukumu skaitu, kas var būt liels veiktspējas vājais punkts.

4. Optimizējiet uniform atjauninājumus

Minimizējiet uniform atjauninājumu biežumu, īpaši lielām datu struktūrām. Bieži atjauninātu datu gadījumā apsveriet uniform bufera objektu (UBO) vai ēnotāja glabāšanas bufera objektu (SSBO) izmantošanu, lai atjauninātu datus lielākos blokos, uzlabojot efektivitāti. Izvairieties atkārtoti iestatīt atsevišķus uniform mainīgos un kešatmiņā saglabājiet uniform atrašanās vietas, lai izvairītos no atkārtotiem izsaukumiem uz gl.getUniformLocation(). Ja izmantojat UBO vai SSBO, atjauniniet tikai tās bufera daļas, kas ir mainījušās.

5. Izmantojiet Uniform Bufera Objektus (UBO)

UBO grupē saistītus uniformus vienā buferī. Tam ir divas galvenās priekšrocības: (1) tas ļauj atjaunināt vairākas uniform vērtības ar vienu izsaukumu, ievērojami samazinot papildu izmaksas, un (2) tas ļauj vairākiem ēnotājiem dalīties ar vieniem un tiem pašiem uniforma datiem no viena bufera. Tas ir īpaši noderīgi ainas datiem, piemēram, projekcijas matricām, skatu matricām un gaismas parametriem, kas ir konsekventi vairākos objektos. Vienmēr izmantojiet `std140` izkārtojumu saviem UBO, lai nodrošinātu starpplatformu saderību un efektīvu datu iepakošanu.

6. Izmantojiet ēnotāja glabāšanas bufera objektus (SSBO), kad tas ir piemērots

SSBO nodrošina daudzpusīgu līdzekli datu glabāšanai un manipulēšanai ēnotājos, piemērots tādiem uzdevumiem kā lielu datu kopu glabāšana, daļiņu sistēmas vai sarežģītu aprēķinu veikšana tieši GPU. SSBO ir īpaši noderīgi datiem, kurus gan lasa, gan raksta ēnotājs. Tie var piedāvāt ievērojamus veiktspējas ieguvumus, izmantojot GPU paralēlās apstrādes iespējas. Nodrošiniet efektīvu atmiņas izkārtojumu savos SSBO optimālai veiktspējai.

7. Uniform atrašanās vietu kešatmiņa

gl.getUniformLocation() var būt salīdzinoši lēna operācija. Saglabājiet uniform atrašanās vietas savā JavaScript kodā, inicializējot ēnotāja programmas, un atkārtoti izmantojiet šīs atrašanās vietas visā renderēšanas ciklā. Tas ļauj izvairīties no atkārtotas GPU vaicāšanas pēc vienas un tās pašas informācijas, kas var ievērojami uzlabot veiktspēju, īpaši sarežģītās ainās ar daudziem uniform mainīgajiem.

8. Izmantojiet virsotņu masīva objektus (VAO) (WebGL 2)

Virsotņu masīva objekti (VAO) WebGL 2 ietver virsotņu atribūtu rādītāju, bufera piesaistu un citu ar virsotnēm saistītu datu stāvokli. VAO izmantošana vienkāršo dažādu virsotņu izkārtojumu iestatīšanas un pārslēgšanās procesu. Piesaistot VAO pirms katra zīmēšanas izsaukuma, jūs varat viegli atjaunot virsotņu atribūtus un bufera piesaistes, kas saistītas ar šo VAO. Tas samazina nepieciešamo stāvokļa maiņu skaitu pirms renderēšanas un var ievērojami uzlabot veiktspēju, īpaši atveidojot daudzveidīgu ģeometriju.

9. Optimizējiet tekstūras formātus un kompresiju

Izvēlieties piemērotus tekstūras formātus un kompresijas metodes, pamatojoties uz jūsu mērķa platformu un vizuālajām prasībām. Saspiestu tekstūru (piemēram, S3TC/DXT) izmantošana var ievērojami samazināt atmiņas joslas platuma izmantošanu un uzlabot renderēšanas veiktspēju, īpaši mobilajās ierīcēs. Esiet informēti par atbalstītajiem kompresijas formātiem ierīcēs, uz kurām mērķējat. Ja iespējams, izvēlieties formātus, kas atbilst mērķa ierīču aparatūras iespējām.

10. Profilēšana un atkļūdošana

Izmantojiet pārlūkprogrammas izstrādātāju rīkus vai specializētus profilēšanas rīkus, lai identificētu veiktspējas vājos punktus jūsu WebGL lietojumprogrammā. Analizējiet zīmēšanas izsaukumu skaitu, tekstūru piesaistes un citas stāvokļa izmaiņas. Profilējiet savus ēnotājus, lai identificētu veiktspējas problēmas. Tādi rīki kā Chrome DevTools sniedz vērtīgu ieskatu WebGL veiktspējā. Atkļūdošanu var vienkāršot, izmantojot pārlūkprogrammas paplašinājumus vai specializētus WebGL atkļūdošanas rīkus, kas ļauj pārbaudīt buferu, tekstūru un ēnotāja mainīgo saturu.

Uzlabotas tehnikas un apsvērumi

1. Datu iepakošana un izlīdzināšana

Pareiza datu iepakošana un izlīdzināšana ir būtiska optimālai veiktspējai, īpaši izmantojot UBO un SSBO. Efektīvi iepakojiet savas datu struktūras, lai minimizētu izšķērdēto vietu un nodrošinātu, ka dati ir izlīdzināti atbilstoši GPU prasībām. Piemēram, `std140` izkārtojuma izmantošana jūsu GLSL kodā ietekmēs datu izlīdzināšanu un iepakošanu.

2. Zīmēšanas izsaukumu grupēšana (Draw Call Batching)

Zīmēšanas izsaukumu grupēšana ir spēcīga optimizācijas tehnika, kas ietver vairāku zīmēšanas izsaukumu grupēšanu vienā izsaukumā, samazinot izmaksas, kas saistītas ar daudzu individuālu zīmēšanas komandu izsniegšanu. Varat grupēt zīmēšanas izsaukumus, izmantojot vienu un to pašu ēnotāja programmu, materiālu un virsotnes datus, un apvienojot atsevišķus objektus vienā tīklā. Dinamiskiem objektiem apsveriet tādas metodes kā dinamiskā grupēšana, lai samazinātu zīmēšanas izsaukumus. Daži spēļu dzinēji un WebGL ietvari automātiski apstrādā zīmēšanas izsaukumu grupēšanu.

3. Atmešanas tehnikas (Culling Techniques)

Izmantojiet atmešanas tehnikas, piemēram, frustum culling un occlusion culling, lai izvairītos no objektu atveidošanas, kas nav redzami kamerai. Frustum culling novērš objektus ārpus kameras redzamības lauka. Occlusion culling izmanto metodes, lai noteiktu, vai objekts ir paslēpts aiz citiem objektiem. Šīs tehnikas var ievērojami samazināt zīmēšanas izsaukumu skaitu un uzlabot veiktspēju, īpaši ainās ar daudziem objektiem.

4. Adaptīvais detaļu līmenis (LOD)

Izmantojiet adaptīvo detaļu līmeņa (LOD) tehnikas, lai samazinātu objektu ģeometrisko sarežģītību, tiem attālinoties no kameras. Tas var dramatiski samazināt apstrādājamo un atveidojamo datu apjomu, īpaši ainās ar lielu skaitu attālu objektu. Ieviesiet LOD, aizstājot detalizētākos tīklus ar zemākas izšķirtspējas versijām, objektiem attālinoties. Tas ir ļoti izplatīts 3D spēlēs un simulācijās.

5. Asinhrona resursu ielāde

Ielādējiet resursus, piemēram, tekstūras un modeļus, asinhroni, lai izvairītos no galvenās pavediena bloķēšanas un lietotāja saskarnes iesaldēšanas. Izmantojiet Web Workers vai asinhronās ielādes API, lai ielādētu resursus fonā. Ielādes laikā parādiet ielādes indikatoru, lai sniegtu atgriezenisko saiti lietotājam. Nodrošiniet pareizu kļūdu apstrādi un rezerves mehānismus gadījumā, ja resursu ielāde neizdodas.

6. GPU vadīta atveidošana (Advanced)

GPU vadīta atveidošana ir sarežģītāka tehnika, kas izmanto GPU iespējas, lai pārvaldītu un plānotu atveidošanas uzdevumus. Šī pieeja samazina CPU iesaistīšanos atveidošanas cauruļvadā, potenciāli radot ievērojamus veiktspējas ieguvumus. Lai gan sarežģītāka, GPU vadīta atveidošana var nodrošināt lielāku kontroli pār atveidošanas procesu un ļaut veikt sarežģītākas optimizācijas.

Praktiski piemēri un koda fragmenti

Ilustrēsim dažus apspriestos jēdzienus ar koda fragmentiem. Šie piemēri ir vienkāršoti, lai sniegtu pamata principus. Vienmēr pārbaudiet to lietošanas kontekstu un apsveriet pārlūkprogrammu saderību. Atcerieties, ka šie piemēri ir ilustratīvi, un faktiskais kods būs atkarīgs no jūsu konkrētās lietojumprogrammas.

Piemērs: tekstūras piesaiste WebGL 1

Šeit ir piemērs tekstūras piesaistei WebGL 1.

            // Create a texture object
const texture = gl.createTexture();

// Bind the texture to the TEXTURE_2D target
gl.bindTexture(gl.TEXTURE_2D, texture);

// Set the parameters of the texture
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.REPEAT);
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.REPEAT);
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);

// Upload the image data to the texture
gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, image);

// Get the uniform location
const textureLocation = gl.getUniformLocation(shaderProgram, 'u_texture');

// Activate texture unit 0
gl.activeTexture(gl.TEXTURE0);

// Bind the texture to texture unit 0
gl.bindTexture(gl.TEXTURE_2D, texture);

// Set the uniform value to the texture unit
gl.uniform1i(textureLocation, 0);

            

              
                Copy
              
            
          

Piemērs: UBO piesaiste WebGL 2

Šeit ir piemērs Uniform Bufera Objekta (UBO) piesaistei WebGL 2.

            // Create a uniform buffer object
const ubo = gl.createBuffer();

// Bind the buffer to the UNIFORM_BUFFER target
gl.bindBuffer(gl.UNIFORM_BUFFER, ubo);

// Allocate space for the buffer (e.g., in bytes)
const bufferSize = 2 * 4 * 4; // Assuming 2 mat4's
gl.bufferData(gl.UNIFORM_BUFFER, bufferSize, gl.DYNAMIC_DRAW);

// Get the index of the uniform block
const blockIndex = gl.getUniformBlockIndex(shaderProgram, 'Matrices');

// Bind the uniform block to a binding point (0 in this case)
gl.uniformBlockBinding(shaderProgram, blockIndex, 0);

// Bind the buffer to the binding point
gl.bindBufferBase(gl.UNIFORM_BUFFER, 0, ubo);

// Inside the shader (GLSL)
// Declare the uniform block
const shaderSource = `
layout(std140) uniform Matrices {
  mat4 u_modelViewMatrix;
  mat4 u_projectionMatrix;
};
`;

            

              
                Copy
              
            
          

Piemērs: instancēšana ar virsotnes atribūtiem

Šajā piemērā instancēšana zīmē vairākus kubus. Šis piemērs izmanto virsotnes atribūtus, lai nodotu instancei specifiskus datus.

            // Inside the vertex shader
const vertexShaderSource = `
#version 300 es
in vec3 a_position;
in vec3 a_instanceTranslation;
uniform mat4 u_modelViewMatrix;
uniform mat4 u_projectionMatrix;

void main() {
  mat4 instanceMatrix = mat4(1.0);
  instanceMatrix[3][0] = a_instanceTranslation.x;
  instanceMatrix[3][1] = a_instanceTranslation.y;
  instanceMatrix[3][2] = a_instanceTranslation.z;

  gl_Position = u_projectionMatrix * u_modelViewMatrix * instanceMatrix * vec4(a_position, 1.0);
}
`;

// In your JavaScript code
// ... vertex data and element indices (for one cube)
// Create an instance translation buffer
const instanceTranslations = [  // Example data
  1.0, 0.0, 0.0,
  -1.0, 0.0, 0.0,
  0.0, 1.0, 0.0,
];
const instanceTranslationBuffer = gl.createBuffer();
gl.bindBuffer(gl.ARRAY_BUFFER, instanceTranslationBuffer);
gl.bufferData(gl.ARRAY_BUFFER, new Float32Array(instanceTranslations), gl.STATIC_DRAW);

// Enable the instance translation attribute
const a_instanceTranslationLocation = gl.getAttribLocation(shaderProgram, 'a_instanceTranslation');
gl.enableVertexAttribArray(a_instanceTranslationLocation);
gl.bindBuffer(gl.ARRAY_BUFFER, instanceTranslationBuffer);
gl.vertexAttribPointer(a_instanceTranslationLocation, 3, gl.FLOAT, false, 0, 0);
gl.vertexAttribDivisor(a_instanceTranslationLocation, 1); // Tell the attribute to advance every instance

// Render loop
gl.drawElementsInstanced(gl.TRIANGLES, numIndices, gl.UNSIGNED_SHORT, 0, instanceCount);

            

              
                Copy
              
            
          

Secinājums: tīmekļa grafikas pilnveidošana

WebGL ēnotāja resursu piesaistes apgūšana ir kritiska augstas veiktspējas un vizuāli pievilcīgu tīmekļa grafikas lietojumprogrammu veidošanai. Izprotot pamatkoncepcijas, ieviešot labāko praksi un izmantojot WebGL 2 (un jaunāku versiju!) uzlabotās funkcijas, izstrādātāji var optimizēt resursu pārvaldību, minimizēt veiktspējas vājos punktus un radīt vienmērīgas, interaktīvas pieredzes plašā ierīču un pārlūkprogrammu klāstā. No tekstūras izmantošanas optimizēšanas līdz efektīvai UBO un SSBO izmantošanai, šajā emuāra ierakstā aprakstītās metodes dos jums iespēju atraisīt pilnu WebGL potenciālu un radīt satriecošas grafikas pieredzes, kas piesaista lietotājus visā pasaulē. Nepārtraukti profilējiet savu kodu, sekojiet līdzi jaunākajiem WebGL jaunumiem un eksperimentējiet ar dažādām metodēm, lai atrastu labāko pieeju saviem konkrētajiem projektiem. Tīmeklim attīstoties, pieaug arī pieprasījums pēc augstas kvalitātes, ieskaujošas grafikas. Izmantojiet šīs metodes, un jūs būsiet labi sagatavoti, lai apmierinātu šo pieprasījumu.